COLLAPSE OS FOR THE MICROBEE PREMIUM - WORD REFERENCE
=====================================================

Every word (command) in this build, in alphabetical order: symbols
first, then A to Z. Words in the boot image work at once; words
marked "Loader" pull more software in from the disk blocks.

HOW TO READ AN ENTRY
  The stack picture shows what a word takes and leaves:
      before -- after       the rightmost item is the top of stack.
  a b n u = numbers, a = address, c = character/byte, f = flag
  (0 = false, anything else true), s = string (length byte + text),
  w = word address, pos = screen position (line*80 + column),
  ? = may or may not be there, x / ... = taken from what you type next.

THE BASICS
  - Separate everything with spaces. "2 3 + ." prints 5.
  - Numbers are 16-bit integers: 0..65535 (or -32768..32767).
    $ff is hex, 'A' is the character code 65. No decimals (3.5).
  - : name ... ;  defines a new word. if/else/then, begin/until,
    for/next, ." and S" only work inside such definitions.
  - ." and S" and ( and \ need a space after them.
  - Upper and lower case are different: DUP is not dup.
  - Words marked internal are machinery; you will not need them.

----------------------------------------------------------------------

!            n a --
             Store the 16-bit number n at address a.  Ex: 1234 $8000 !

'            x ( -- w )
             Address (wordref) of word x. Aborts if x is not found.  Ex:
             ' dup

'?           x ( -- w-or-0 )
             Like ' but gives 0 instead of aborting when x is not found.

(            ( -- )
             Comment: ignores everything up to the next ). Needs a space
             after it.  Ex: ( this is a comment )

(?br)        internal
             Conditional branch, compiled by if/until. Not for direct
             use.

(b)          internal
             Pushes an 8-bit literal; compiled by litn. Not for direct
             use.

(blk!)       blk src --
             Microbee disk driver: write 1024 bytes at src as block blk
             (sectors 4096+2*blk and +1). Use blk! / flush instead.

(blk@)       blk dst --
             Microbee disk driver: read block blk into 1024 bytes at dst.
             Use blk@ / list instead.

(br)         internal
             Unconditional branch, compiled by else/again. Not for direct
             use.

(emit)       c --
             The screen driver behind emit (Grid subsystem): shows c at
             the cursor and moves on. Handles CR (new line) and BS.

(im1)        --
             Enables Z80 interrupt mode 1. DO NOT USE on the Microbee:
             there is no handler and it will crash.

(key?)       -- c? f
             The Microbee keyboard driver behind key?. Returns a
             character and 1 for a newly pressed key, otherwise just 0.

(n)          internal
             Pushes a 16-bit literal; compiled by litn. Not for direct
             use.

(next)       internal
             Loop counter step, compiled by next. Not for direct use.

(wnf)        --
             "Word not found": prints the bad word and aborts. Called
             through WNF.

*            a b -- a*b
             Multiply (16-bit, overflow is lost).  Ex: 6 7 * .  -> 42

+            a b -- a+b
             Add.  Ex: 2 3 + .  -> 5

+!           n a --
             Add n to the number stored at address a.

,            n --
             Write 16-bit n at HERE and move HERE on 2 bytes (builds data
             in the dictionary).

,"           ..." ( -- )
             Writes the characters up to the next " at HERE (no length
             byte).

-            a b -- a-b
             Subtract.  Ex: 10 3 - .  -> 7

-^           a b -- b-a
             Subtract the other way round.  Ex: 10 3 -^ .  -> -7

.            n --
             Print n in decimal (no space after it: use spc> between
             numbers).  Ex: 42 .

."           ..." ( -- )
             Inside a definition only: prints the text up to the next ".
             Needs a space after it.  Ex: : hi ." Hello" ; hi

.S           --
             Show the stack size and contents without changing it. Very
             useful while learning.

.free        --
             Microbee: print the bytes free.  Ex: .free  -> 51815 bytes
             free

.X           n --
             Print n as 4 hex digits.  Ex: 255 .X  -> 00ff

.x           n --
             Print the low byte of n as 2 hex digits.  Ex: 255 .x  -> ff

/            a b -- a/b
             Divide, whole numbers only (remainder dropped).  Ex: 7 2 / .
             -> 3

/mod         a b -- r q
             Divide giving remainder r and quotient q.  Ex: 7 2 /mod .
             spc> .  -> 3 1

:            x ... ;
             Define a new word x. Everything up to ; is compiled.  Ex: :
             sq dup * ;  then 5 sq .  -> 25

;            --
             Ends a : definition.

;code        --
             Ends a code (native Z80) definition: compiles the jump back
             to the interpreter.

<            a b -- f
             True if a < b.

<<           n -- n
             Shift left one bit (times 2).

<<8          n -- n
             Shift left 8 bits (times 256).

<=           a b -- f
             True if a <= b.

=            a b -- f
             True if a equals b.

=><=         n lo hi -- f
             True if lo <= n <= hi.  Ex: 5 1 9 =><= .  -> 1

>            a b -- f
             True if a > b.

>=           a b -- f
             True if a >= b.

>>           n -- n
             Shift right one bit (divide by 2).

>>8          n -- n
             Shift right 8 bits (the high byte).

>A           n --
             Put n in the A register (a handy spare register for memory
             loops).

>r           n --
             Move n to the return stack. Must be taken back (r> or r~) in
             the same word.

?dup         n -- n n  or  0 -- 0
             Copy n only if it is not zero.

?swap        a b -- lo hi
             Sort two numbers, the higher one on top.

@            a -- n
             Fetch the 16-bit number at address a.  Ex: $f000 @ .X

[            --
             Inside a definition: stop compiling and run the following
             words now (until ]).

[']          x ( -- )
             Inside a definition: compile the address of x as a number.

[]=          a1 a2 u -- f
             True if the u bytes at a1 and a2 are the same.

[compile]    x ( -- )
             Inside a definition: compile x even if it is an immediate
             word.

[if]         f [if] ... [then]
             Skip everything up to [then] if f is false. Works outside
             definitions (no [else]).

[then]       --
             Ends [if].

\            ( -- )
             Comment to the end of the line. Needs a space after it.  Ex:
             2 3 + . \ add them

\s           --
             In a block being loaded: stop loading the rest of the block.

]            --
             Start compiling again (after [).

_            internal
             Helper name used inside the core and drivers. Not for direct
             use.

_bchk        n -- n
             Aborts with "br ovfl" if n is not a valid short branch
             offset (-128..127). Internal.

_crt         -- a
             Microbee: the 6545 CRTC register table used by vid$
             (internal).

_kl          -- a
             Microbee: the unshifted key map, 64 bytes (internal).

_ks          -- a
             Microbee: the shifted key map, 64 bytes (internal).

0<           n -- f
             True if n is negative (as a signed number).

0>=          n -- f
             True if n is zero or positive (as a signed number).

1+           n -- n+1
             Add one.

1-           n -- n-1
             Subtract one.

2drop        a b --
             Drop the top two items.

2dup         a b -- a b a b
             Copy the top two items.

6502a        --
             Loader: loads the 6502 assembler from disk blocks.

6502c        --
             Loader: loads the 6502 boot code (for cross-compiling
             Collapse OS).

6502d        --
             Loader: loads the 6502 disassembler.

6502m        --
             Loader: loads 6502 macros (for cross-compiling).

6809a        --
             Loader: loads the 6809 assembler.

6809c        --
             Loader: loads the 6809 boot code (for cross-compiling).

8086a        --
             Loader: loads the 8086 assembler.

8086c        --
             Loader: loads the 8086 boot code (for cross-compiling).

A+           --
             Add one to the A register.

A-           --
             Subtract one from the A register.

A>           -- n
             Copy the A register to the stack.

A>r          --
             Push the A register on the return stack.

abort        --
             Empty both stacks and return to the prompt.

abort"       ..." ( -- )
             Inside a definition: print the text, then abort.  Ex: : chk
             0< if abort" negative!" then ;

Ac!          c --
             Store byte c at the address in A.

Ac!+         c --
             Store byte c at the address in A, then A+1.

Ac@          -- c
             Fetch the byte at the address in A.

Ac@+         -- c
             Fetch the byte at the address in A, then A+1.

again        --
             Ends begin ... again: loop forever (leave it with exit or
             abort).

alias        x y ( -- )
             Make y another name for x.  Ex: alias dup dupe

allot        n --
             Reserve n bytes at HERE (moves HERE on).

allot0       n --
             Reserve n bytes at HERE, filled with zeros.

and          a b -- a&b
             Bitwise AND.  Ex: $ff0f $00ff and .X  -> 000f

at-xy        x y --
             Move the screen cursor to column x, line y (from 0).  Ex: 10
             5 at-xy ." here"

avra         --
             Loader: loads the AVR assembler.

begin        --
             Starts a loop: begin ... f until  or  begin ... again.

blk!         --
             Write the current block to disk if it was changed.

blk!!        --
             Mark the current block as changed (so it will be written).

blk$         --
             Reset the block system (no block in memory). Done at start-
             up.

blk(         -- a
             Address of the 1024-byte block buffer.

blk)         -- a
             Address just after the block buffer.

BLK>         -- a
             Address of the current block number (see blk>).

blk>         -- n
             Number of the block in memory (-1 for none).

blk@         n --
             Read block n into the buffer (saving a changed block first).

BLKDTY       -- a
             Address of the "block changed, not yet saved" flag.

BLKIN>       -- a
             Address used by load to save the input position (internal).

boot         --
             Restart Collapse OS fresh: everything you defined is
             forgotten.

BS           -- 8
             The backspace character code.

bs?          c -- f
             True if c is backspace (8) or delete (127).

bye          --
             Halts the Z80. On the Microbee you then have to reset.

c!           c a --
             Store the byte c at address a.  Ex: 65 $f000 c!  puts A top
             left

c!+          c a -- a+1
             Store byte c at a, give back a+1.

c,           c --
             Write byte c at HERE and move HERE on 1.

c@           a -- c
             Fetch the byte at address a.

c@+          a -- a+1 c
             Fetch the byte at a, and give a+1 too.

calli!       n a -- len
             Write a native call to n at address a (internal).

cell         -- 2
             Size of a cell in bytes.

cell!        c pos --
             Put character c on screen at position pos (y*80+x), cursor
             unchanged.  Ex: 42 0 cell!

cells        n -- n*2
             Bytes needed for n cells.

cells!       a pos u --
             Copy u characters from address a to the screen at pos.

cidx         c a u -- i? f
             Find byte c in the u bytes at a. Gives index i and 1, or
             just 0.

clrscr       --
             Clear the screen and put the cursor top left.

code         x ( -- )
             Start a native Z80 word x (needs the assembler: z80a). End
             it with ;code.

COLS         -- 80
             Screen width in characters.

compile      x ( -- )
             Inside an immediate word: compile code that will compile x
             later (advanced).

COMPILING    -- a
             Address of the compiling flag (1 while inside a :
             definition).

consts       n ( -- )
             Make n constants:  3 consts 1 one 2 two 3 three

copy         src dst --
             Copy block src to block dst (on disk).

CR           -- 13
             The carriage return character code.

crc16        c b -- c
             Add byte b to the 16-bit CRC c (XMODEM CRC).

create       x ( -- )
             Make a word x that pushes its data address; follow with , c,
             or allot.  Ex: create tbl 1 , 2 , 3 ,   tbl 2 + @ .  -> 2

crtc!        val reg --
             Microbee: write val to 6545 CRTC register reg.

CURRENT      -- a
             Address holding the last dictionary entry (see current).

current      -- a
             Address of the last word defined.

cursor!      new old --
             Microbee: move the hardware cursor (used by the Grid; use
             at-xy instead).

CURWORD      -- a
             Address of the buffer holding the last word read (see
             curword).

curword      -- s
             The last word read, as a string.

doer         x ( -- )
             With does>, makes defining words:  : printer doer , does> @
             . ;  42 printer foo  foo  -> 42

does>        --
             Gives the behaviour of words made with doer (see doer).

drop         a --
             Throw away the top item.

dump         n a --
             Hex dump n bytes from address a.  Ex: 32 $0000 dump

dup          a -- a a
             Copy the top item.

ed           --
             Loader: loads the line (command) editor from disk. See
             EDITORS below.

else         --
             In  f if A else B then : B runs when f is false.

EMIT         -- a
             Address of the emit vector. ' myemit EMIT ! redirects all
             output.

emit         c --
             Print character c.  Ex: 65 emit  -> A

emitln       a --
             Print the 64-character line at a (used by list).

EOT          -- 4
             The end-of-transmission character code.

execute      w --
             Run the word whose address is w.  Ex: 5 ' . execute  -> 5

exit         --
             Leave the current word now (also leaves a begin loop).

fill         a n b --
             Fill n bytes at a with b.  Ex: $f000 80 '*' fill

fillc        pos n c --
             Fill n screen cells from pos with character c.

find         s -- w-or-0
             Look up the string s in the dictionary.

flush        --
             Write the changed block to disk now and forget the buffer.
             Do this before you stop.

fmtd         n a -- sa sl
             Format n in decimal into memory at a.

fmtX         n a -- sa sl
             Format n as 4 hex digits into memory at a.

fmtx         n a -- sa sl
             Format the low byte of n as 2 hex digits at a.

for          n for ... next
             Repeat n times. r@ inside gives the count, n down to 1.  Ex:
             : stars for 42 emit next ; 5 stars

forget       x ( -- )
             Remove word x and everything defined after it.

free         -- n
             Microbee: bytes of memory free, from here to the block
             buffer. Ex: free u.  -> 51862 (about 52K at start-up)

grid$        --
             Reset the screen cursor position (done at start-up).

hd!          sec src --
             Microbee: write 512 bytes at src to disk sector sec.
             CAREFUL: sectors 0-2047 hold the boot code.

hd<          a --
             Microbee: read 512 bytes from the disk data port to a
             (internal).

hd>          a --
             Microbee: write 512 bytes from a to the disk data port
             (internal).

hd@          sec dst --
             Microbee: read disk sector sec (512 bytes) to dst.  Ex: 4096
             $8000 hd@

hderr        --
             Microbee: prints "disk error" and aborts.

hdsec        sec --
             Microbee: set the disk controller to sector sec (internal).

hdwait       -- st
             Microbee: wait for the disk controller, give its status
             (internal).

HERE         -- a
             Address holding the next free dictionary address (see here).

here         -- a
             The next free address in the dictionary.

if           f if ... then
             Run the words up to then (or else) only if f is true (not
             0).  Ex: : pos? 0< if ." neg" else ." pos" then ;

imm?         w -- f
             True if the word at w is immediate.

immediate    --
             Make the last defined word immediate (runs even while
             compiling).

in$          --
             Throw away the rest of the input line.

IN(          -- a
             Address holding the start of the input buffer.

in(          -- a
             Start of the input buffer.

in)          -- a
             End of the input buffer.

in<          -- c
             Next character of input (reads a new line when needed).

in<?         -- c-or-0
             Next character of input, or 0 at the end of the line.

IN>          -- a
             Address holding the current position in the input buffer.

in>          -- a
             Current position in the input buffer.

INBUF        -- a
             Address of the input line buffer.

index        b1 b2 --
             Show the first line (the title) of blocks b1 to b2.  Ex: 0
             30 index

info         --
             Microbee: a short system report: memory used and free (and
             where), the disk, the screen, the ink and caps lock.

init         --
             Microbee start-up: screen, disk blocks, keyboard. Run by
             boot.

ink          n --
             Microbee: the colour of characters written from now on.
             Low 4 bits the character, high 4 the background. On the
             Premium (and uBee512): 0 black 1 red 2 green 3 yellow 4 blue
             5 magenta 6 cyan 7 white, +8 bright (9 bright red/orange,
             10 bright green, 11 bright yellow, 12 bright blue ...).
             Ex: 11 ink (yellow), 75 ink (yellow on blue: 4*16+11),
             10 ink (back to the usual green). VibeDrone shows the
             character colour in PC order (1 blue, 4 red) unless the byte
             at 0090 is 0, which it isn't in Collapse OS: there 12 shows
             light red, 9 light blue, 14 yellow. Green (10) is the same
             in both.

INK0         -- n
             Microbee: the colour Collapse OS starts in, 10 (light green
             on black). vid$ sets the whole screen to it.

interpret    --
             The main interpreter loop.

IOERR        -- a
             Address of the I/O error flag set by some drivers.

jmpi!        n a -- len
             Write a native jump to n at address a (internal).

kchar        k -- c? f
             Microbee: the character for key k (internal).

key          -- c
             Wait for a key and give its character.  Ex: key emit

KEY?         -- a
             Address of the key? vector. ' mykey? KEY? ! changes the
             keyboard source.

key?         -- c? f
             Check for a key without waiting: c and 1, or just 0.

key@         k -- f
             Microbee: is matrix key k (0-63) held down now? 57 is Ctrl,
             63 Shift.  Ex: 63 key@ .

knew         k -- f
             Microbee: has key k just gone down? (internal).

l,           n --
             Write n at HERE low byte first.

lamp         f i --
             Microbee: light lamp i (0-8) of the lamp panel (f true),
             or put it out. Ex: 1 4 lamp

lamps        n --
             Microbee: set all 9 lamps from bits 0-8 of n (bit 0 the
             leftmost). Ex: $1ff lamps (all lit), 0 lamps (all out). A
             key press lights a random pattern; the panel is the 25th
             line, which Collapse OS's text (24 lines) leaves alone.

leave        --
             In for ... next: stop the loop at the next "next".

LF           -- 10
             The line feed character code.

LINES        -- 24
             Screen height in lines (the 25th is the lamp panel).

list         n --
             Show block n (16 lines of 64).  Ex: 0 list

litn         n --
             Compile n as a number (inside immediate words).

LN<          -- a
             Address of the routine that feeds input lines (normally
             rdln).

lnlen        a -- n
             Length of the 64-character line at a, up to its last visible
             character.

LNSZ         -- 64
             Line length: the input buffer, and each block line.

lntype       ptr c -- ptr' f
             One key of line entry (used by rdln, internal).

load         n --
             Run the Forth code in block n.  Ex: 400 load

loadr        n1 n2 --
             Load blocks n1 to n2.  Ex: 400 402 loadr

lshift       n u -- n
             Shift n left u bits.

l|m          n -- lsb msb
             Split n into its low and high bytes.

m,           n --
             Write n at HERE high byte first.

max          a b -- max
             The larger of a and b.

me           --
             Loader: loads the memory (hex) editor; type me again to run
             it. See EDITORS.

min          a b -- min
             The smaller of a and b.

mod          a b -- a%b
             Remainder.  Ex: 7 3 mod .  -> 1

move         a1 a2 u --
             Copy u bytes from a1 to a2.

move,        a u --
             Copy u bytes from a to HERE.

nc,          n ...
             Read the next n numbers from input and write them as bytes.
             Ex: create b 3 nc, 1 2 3

newln        old -- new
             Microbee: the screen's new-line handler (clears/scrolls;
             internal).

next         --
             Ends a for ... next loop.

NEXTWORD     -- a
             Address of the "next word" override used by word!.

nip          a b -- b
             Drop the second item.

NL           -- a
             Address of the newline characters nl> sends (CR LF).

nl>          --
             Print a new line.

noop         --
             Does nothing.

not          f -- f
             Logical not: 0 becomes 1, anything else 0.

or           a b -- a
             b|Bitwise OR.  Ex: $f0 $0f or .X  -> 00ff

over         a b -- a b a
             Copy the second item to the top.

parse        s -- n? f
             Turn string s into a number: n and 1, or just 0.

pc!          c port --
             Z80 OUT: send byte c to I/O port. Careful: ports drive the
             hardware.

pc@          port -- c
             Z80 IN: read a byte from I/O port.  Ex: $47 pc@ .x  (disk
             status)

psdump       --
             Print the stack contents (used by .S).

quit         --
             Empty the return stack and go back to the prompt.

r>           -- n
             Take n back from the return stack.

r>A          --
             Pop the return stack into the A register.

r@           -- n
             Copy the top of the return stack (the for ... next count).

rcnt         -- n
             Bytes used on the return stack.

rdln         --
             Read a line from the keyboard into the input buffer.

rnd          k -- n
             Microbee: the lamps' random number (16-bit xorshift),
             stirred with k. Ex: 0 rnd .

rot          a b c -- b c a
             Rotate the third item to the top.

rot>         a b c -- c a b
             Rotate the top item to third.

rshift       n u -- n
             Shift n right u bits.

rtype        a u --
             Print the u characters at a.

run1         --
             Interpret the next word of input (internal).

r~           --
             Drop the top of the return stack.

S"           ..." ( -- s )
             Inside a definition: a string literal (address of a length
             byte then the text). Needs a space after it.  Ex: : msg S"
             Hi" stype ;

s=           s1 s2 -- f
             True if the strings s1 and s2 are equal.

scnt         -- n
             Bytes used on the data stack.

SPC          -- 32
             The space character code.

spc>         --
             Print a space.

stack?       --
             Aborts with "stack underflow" if the stack is below empty.

stype        s --
             Print string s (from S").

stypec       s pos --
             Print string s on screen at pos, cursor unchanged.

swap         a b -- b a
             Swap the top two items.

then         --
             Ends if ... then / if ... else ... then.

to           to x
             Make the next value x store instead of fetch.  Ex: 5 value v
             9 to v  v .  -> 9

toword       -- c
             Skip spaces in the input, give the first character
             (internal).

tuck         a b -- b a b
             Copy the top item under the second.

u.           n --
             Print n in decimal as 0 to 65535 (. prints -32768 to
             32767). Ex: 40000 u.

until        f --
             Ends begin ... until: loops back to begin while f is false.
             Ex: : cnt 0 begin 1+ dup . dup 5 = until drop ;

value        n value x
             Make x a value holding n; x gives n, "to x" changes it.  Ex:
             10 value lives

values       n ( -- )
             Make n values, all 0:  3 values a b c

ve           --
             Loader: loads the visual editor (about 10 s); type ve again
             to run it. See EDITORS.

vid$         --
             Microbee: set up the screen again (CRTC, colours: all INK0,
             and ink back to INK0). Use clrscr after it.

waitw        s --
             Skip input words until one equals string s.

wipe         --
             Fill the current block with spaces (marks it changed).

WNF          -- a
             Address of the "word not found" handler (normally (wnf)).

word         -- s
             Read the next word from input as a string.

word!        s --
             Make the next "word" give s instead of reading input.

ws?          c -- f
             True if c is a space or control character.

xcomp        --
             Loader: the cross-compilation tools.

xcompc       --
             Loader: the Collapse OS cross-compiler.

xor          a b -- a^b
             Bitwise exclusive OR.

xtcomp       --
             Starts compiling a : definition (internal).

XYPOS        -- a
             Address of the screen cursor position (see xypos).

xypos        -- pos
             The screen cursor position (y*80+x).

xypos!       pos --
             Move the screen cursor to pos.

z80a         --
             Loader: loads the Z80 assembler (needed for code ... ;code).

z80c         --
             Loader: loads the Z80 boot code (for cross-compiling
             Collapse OS).

----------------------------------------------------------------------
EDITORS

VISUAL EDITOR: type ve (loads, about 10 s), then ve again to run.
  Digits first give a count/number (the "modifier"), e.g. 400G.
  G  go to block (400G)      [ ]  previous / next block
  h l  left / right          j k  down / up
  H  start of line           L  end of line
  w  next word   W  end of word   b  previous word   g  go to line
  R  type over text (Return ends)
  I  insert text (type it, Return ends)
  o / O  new line after / before     D  delete line(s)
  X  delete characters       F  find text   n  find next
  N  find next, also in the following blocks
  f  select from previous cursor position   E  delete selection
  Y  copy selection          C  change selection
  m / t  set / go to bookmark   @  undo changes to this block
  !  save block now          &  wipe block (undo with @)
  q  quit, then type  flush  to be sure everything is saved
  Status line: BLK number, modifier, line,column, * = changed.

LINE EDITOR: type ed (loads it). Works on the block last listed.
  n t      select line n (e.g. 3 t) and show it
  p xxx    put xxx as a new line under the selected one
  u xxx    put xxx as a new line above it
  i xxx    insert xxx at the cursor
  f xxx    find xxx (cursor moves in front of it)
  e        delete what f found      n x  delete n characters
  y        copy (length of the find text) into the insert buffer
  l  list this block   n  next block   b  previous block

MEMORY EDITOR: type me (loads), then me again to run.
  h j k l  move   [ ]  page back / on   J K  line back / on
  G  go to a hex address   R  type hex bytes in (Return ends)
  @  read the cell at the cursor onto the stack   !  write it back
  m  push cursor address  g  go to address on stack  f  follow pointer
  q  quit

DISK BLOCKS
  0 list           the master index of the system blocks
  0 to 352         Collapse OS source and the editors (leave alone)
  400 to 499       free for your own code: 400G in ve, then 400 load
  flush            save before you stop. In VibeDrone also export
                   (save) the disk image, or the changes are lost.

More detail: doc/usage.txt, doc/dict.txt, doc/ed.txt in the
Collapse OS zip.
